package c

import (
	"context"
	"errors"
	"fmt"
	"time"

	sysModel "github.com/flipped-aurora/gin-vue-admin/server/model/system"
	"github.com/gin-gonic/gin"

	"github.com/flipped-aurora/gin-vue-admin/server/global"
	common_request "github.com/flipped-aurora/gin-vue-admin/server/model/common/request"
	community_request "github.com/flipped-aurora/gin-vue-admin/server/model/community/request"
	"github.com/flipped-aurora/gin-vue-admin/server/model/content"
	request_model "github.com/flipped-aurora/gin-vue-admin/server/model/content/request"
	response_model "github.com/flipped-aurora/gin-vue-admin/server/model/content/response"
	"github.com/flipped-aurora/gin-vue-admin/server/service/system"
	"github.com/flipped-aurora/gin-vue-admin/server/utils"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

type ContentService struct{}

// GetContentListByCommunity 根据社区类型自动选择查询逻辑
func (con *ContentService) GetContentListByCommunity(req request_model.ListContentRequest, userID uint) (response_model.PageResult, error) {
	var resp response_model.PageResult

	// 1. 判断是否提供了社区ID
	if req.CommunityID == 0 {
		return resp, errors.New("社区ID不能为空")
	}

	// 2. 获取社区信息
	community, err := CommunityServiceApp.GetCommunityByID(uint(req.CommunityID))
	if err != nil {
		return resp, err
	}

	// 3. 根据社区类型选择不同的查询逻辑
	if community.Type == 0 {
		// 学科类社区（虚拟社区）
		// 构造学科类社区查询请求
		disciplineReq := community_request.GetDisciplineCommunityContentRequest{
			CommunityID: community.ID,
			Type:        req.Type,
			PageInfo: common_request.PageInfo{
				Page:     req.Page,
				PageSize: req.PageSize,
			},
		}

		// 调用学科类社区查询方法
		return con.GetDisciplineCommunityContents(disciplineReq, userID)
	} else {
		// 专业类社区（物理社区）
		// 直接调用ListContent方法
		return con.ListContent(req, userID)
	}
}

// ContentServiceApp 内容模块业务层实例
var ContentServiceApp = new(ContentService)

// CreateContent 创建内容
func (con *ContentService) CreateContent(req request_model.CreateContentRequest, publisherID uint) (response_model.ContentResponse, error) {
	var resp response_model.ContentResponse

	// 根据内容类型进行权限校验
	var enableProfRating bool
	var communityID uint
	var err error

	switch req.Type {
	case global.ContentTypeAnswers:
		// 回答类型内容校验
		communityID, enableProfRating, err = con.validateAnswerContent(req, publisherID)
	case global.ContentTypeDynamics:
		// 动态类型内容校验
		communityID, enableProfRating, err = con.validateDynamicContent(req, publisherID)
	case global.ContentTypeQuestions:
		// 提问类型内容校验
		communityID, enableProfRating, err = con.validateQuestionContent(req, publisherID)
	default:
		return resp, errors.New("不支持的内容类型")
	}

	if err != nil {
		return resp, err
	}

	//TODO ai初步审核内容，敏感词检索

	// 使用事务同时创建Content和ContentStats
	// 构造 Content 对象
	newContent := content.Content{
		CommunityID:      communityID,
		PublisherID:      publisherID, // 使用当前登录用户ID
		Type:             req.Type,
		Title:            req.Title,
		Body:             req.Body,
		ParentID:         req.ParentID,
		Status:           global.ContentStatusNormal, // 默认状态为正常
		EnableProfRating: enableProfRating,
	}

	err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		// 保存到数据库
		err := tx.Create(&newContent).Error
		if err != nil {
			return errors.New("创建内容失败: " + err.Error())
		}

		// 创建对应的ContentStats记录，使用已生成的ID
		contentStats := content.ContentStats{
			ContentID:     newContent.ID,
			LikeCount:     0,
			DislikeCount:  0,
			CollectCount:  0,
			ShareCount:    0,
			ViewCount:     0,
			CommentsCount: 0,
		}
		err = tx.Create(&contentStats).Error
		if err != nil {
			return errors.New("创建内容统计失败: " + err.Error())
		}
		return nil
	})

	if err != nil {
		return resp, err
	}

	// 成功了再去更新社区的文章数字段
	// 增加社区文章数量
	go func() {
		if err = CommunityServiceApp.UpdateCommunityArticleCount(communityID, 1); err != nil {
			global.GVA_LOG.Error("创建文章时更新社区文章数失败", zap.Error(err))
		}
	}()

	// 新增：将专业类别社区的内容添加到对应学科类社区的zset中
	go func() {
		// 查询社区信息
		community, err := CommunityServiceApp.GetCommunityByID(communityID)
		if err != nil {
			global.GVA_LOG.Error("获取社区信息失败", zap.Error(err))
			return
		}

		// 判断是否为专业类别社区
		if community.Type == 1 && community.DisciplineCategoryID > 0 {
			// 获取对应的专业类别社区
			disciplineCommunity, err := CommunityServiceApp.GetCommunityByDisciplineID(community.DisciplineCategoryID)
			if err != nil {
				global.GVA_LOG.Error("获取学科类别社区信息失败", zap.Error(err))
				return
			}
			// 获取当前时间戳(秒)
			timestamp := time.Now().Unix()

			// 创建社区Redis工具实例
			communityRedis := utils.NewCommunityRedis()

			// 添加到学科类社区的zset，传入内容类型
			if err := communityRedis.AddContentToDisciplineZSet(
				disciplineCommunity.ID,
				int64(newContent.ID),
				global.ContentType(newContent.Type),
				timestamp,
			); err != nil {
				// 记录错误但不阻止主流程
				global.GVA_LOG.Warn("Failed to update discipline community zset",
					zap.Int("contentID", int(newContent.ID)),
					zap.Error(err))
			}
		}
	}()

	// 转换为响应模型
	resp = convertToResponse(newContent, publisherID)
	return resp, nil
}

// validateAnswerContent 验证回答类型内容的权限
func (con *ContentService) validateAnswerContent(req request_model.CreateContentRequest, publisherID uint) (uint, bool, error) {
	// 1. 验证是否指定了提问ID
	if req.ParentID <= 0 {
		return 0, false, errors.New("创建内容失败: 创建回答需要指定提问")
	}
	// 2. 获取提问所属社区ID
	question, err := CommunityServiceApp.GetQuestionByID(req.ParentID)
	if err != nil {
		return 0, false, err
	}
	// 3. 获取用户信息和专业
	user, err := system.UserServiceApp.GetUserByID(publisherID)
	if err != nil {
		return 0, false, err
	}
	// 4. 检查用户专业是否与社区匹配
	if err := CommunityServiceApp.CheckUserMajorWithCommunity(user.Major, question.CommunityID); err != nil {
		return 0, false, err
	}

	// 回答类型默认启用专业评分
	return question.CommunityID, true, nil
}

// validateDynamicContent 验证动态类型内容的权限
func (con *ContentService) validateDynamicContent(req request_model.CreateContentRequest, publisherID uint) (uint, bool, error) {
	// 1. 获取用户信息
	user, err := system.UserServiceApp.GetUserByID(publisherID)
	if err != nil {
		return 0, false, err
	}

	// 3. 处理社区ID
	var communityID uint
	if req.CommunityID > 0 {
		// 如果传递了社区ID，校验社区是否存在以及是否与用户专业匹配
		if err := CommunityServiceApp.CheckUserMajorWithCommunity(user.Major, req.CommunityID); err != nil {
			return 0, false, err
		}
		communityID = req.CommunityID
	} else {
		// 如果未传递社区ID，使用用户专业对应的社区ID
		communityInfo, err := CommunityServiceApp.GetCommunityByMajorID(user.Major)
		if err != nil {
			return 0, false, err
		}
		communityID = communityInfo.ID
	}

	// 动态类型是否启用专业评分由请求决定
	return communityID, req.EnableProfRating, nil
}

// validateQuestionContent 验证提问类型内容的权限
func (con *ContentService) validateQuestionContent(req request_model.CreateContentRequest, publisherID uint) (uint, bool, error) {
	// 1.提问必须传社区id
	if req.CommunityID <= 0 {
		return 0, false, errors.New("社区id缺失")
	}
	// 2. 提问类型允许发布到其他社区，只需校验社区是否存在
	hive, err := CommunityServiceApp.CheckCommunityExists(req.CommunityID)
	if err != nil || !hive {
		return 0, false, errors.New("查询社区失败: " + err.Error())
	}
	// 提问类型默认不启用专业评分
	return req.CommunityID, false, nil
}

// GetQuestionByID 根据ID获取提问信息
func (s *CommunityService) GetQuestionByID(questionID int64) (content.Content, error) {
	var question content.Content
	err := global.GVA_DB.Where("id = ? AND type = ? AND status = ?", questionID, global.ContentTypeQuestions, global.ContentStatusNormal).First(&question).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return question, errors.New("提问不存在或已被删除")
		}
		return question, err
	}
	return question, nil
}

// UpdateContent 更新内容（仅发布者或管理员可操作）
func (con *ContentService) UpdateContent(req request_model.UpdateContentRequest, userID uint) (response_model.ContentResponse, error) {
	var resp response_model.ContentResponse
	var contentModel content.Content

	// 查询内容，非删除文章均可编辑
	err := global.GVA_DB.Where("id = ? AND status != ?", req.ID, global.ContentStatusDeleted).First(&contentModel).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return resp, errors.New("内容不存在或已被删除")
		}
		return resp, errors.New("查询内容失败: " + err.Error())
	}

	// 检查权限（仅发布者或管理员可操作）
	if contentModel.PublisherID != userID {
		// 这里应该检查是否是管理员，简化处理
		return resp, errors.New("无权限更新此内容")
	}

	// 更新内容
	updates := map[string]interface{}{}
	if req.Title != "" {
		updates["title"] = req.Title
	}
	if req.Body != "" {
		updates["body"] = req.Body
	}

	if len(updates) > 0 {
		err = global.GVA_DB.Model(&contentModel).Updates(updates).Error
		if err != nil {
			return resp, errors.New("更新内容失败: " + err.Error())
		}
	}

	// 转换为响应模型
	resp = convertToResponse(contentModel, userID)
	return resp, nil
}

// DeleteContent 逻辑删除内容（Status = ContentStatusDeleted）
func (con *ContentService) DeleteContent(req request_model.DeleteContentRequest, userID uint) (interface{}, error) {
	var contentModel content.Content

	// 查询内容，封禁与正常都可以删除
	err := global.GVA_DB.Where("id = ? AND status != ?", req.ID, global.ContentStatusDeleted).First(&contentModel).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("内容不存在或已被删除")
		}
		return nil, errors.New("查询内容失败: " + err.Error())
	}

	// 检查权限（仅发布者或管理员可操作）
	if contentModel.PublisherID != userID {
		// 这里应该检查是否是管理员，简化处理
		return nil, errors.New("无权限删除此内容")
	}

	// 在事务中处理内容删除和相关统计记录
	err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		// 逻辑删除内容（更新状态为删除）
		err = tx.Model(&contentModel).Update("status", global.ContentStatusDeleted).Error
		if err != nil {
			return errors.New("删除内容失败: " + err.Error())
		}

		// 可以选择删除对应的ContentStats记录或保留
		// 这里选择保留统计数据，但可以根据业务需求选择删除，建议修改表结构，改为软删除
		//err = tx.Where("content_id = ?", req.ID).Delete(&content.ContentStats{}).Error
		//if err != nil {
		//	return errors.New("删除内容统计失败: " + err.Error())
		//}
		return nil
	})

	if err != nil {
		return nil, err
	}

	// 增加社区文章数量
	go func() {
		if err = CommunityServiceApp.UpdateCommunityArticleCount(contentModel.CommunityID, -1); err != nil {
			global.GVA_LOG.Error("删除文章时更新社区文章数失败", zap.Error(err))
		}
	}()

	// 新增：从学科类社区的zset中移除内容
	go func() {
		// 查询社区信息
		community, err := CommunityServiceApp.GetCommunityByID(contentModel.CommunityID)
		if err != nil {
			global.GVA_LOG.Error("获取社区信息失败", zap.Error(err))
			return
		}

		// 判断是否为专业类别社区
		if community.Type == 1 && community.DisciplineCategoryID > 0 {
			// 获取对应的专业类别社区
			disciplineCommunity, err := CommunityServiceApp.GetCommunityByDisciplineID(community.DisciplineCategoryID)
			if err != nil {
				global.GVA_LOG.Error("获取学科类别社区信息失败", zap.Error(err))
				return
			}
			// 创建社区Redis工具实例
			communityRedis := utils.NewCommunityRedis()

			// 从学科类社区的zset中删除，传入内容类型
			if err := communityRedis.RemoveContentFromDisciplineZSet(
				disciplineCommunity.ID,
				int64(contentModel.ID),
				global.ContentType(contentModel.Type),
			); err != nil {
				// 记录错误但不阻止主流程
				global.GVA_LOG.Warn("Failed to remove content from discipline community zset",
					zap.Int("contentID", int(contentModel.ID)),
					zap.Error(err))
			}
		}
	}()

	return nil, nil
}

// getUserInteraction 获取用户互动状态
func (con *ContentService) getUserInteraction(contentID int64, userID uint) response_model.UserInteraction {
	// 如果用户未登录，返回默认状态
	if userID == 0 {
		return response_model.UserInteraction{
			IsLiked:    false,
			IsDisLiked: false,
			IsMark:     false,
		}
	}

	// 查询用户在该内容上的所有操作
	var actions []content.UserAction
	err := global.GVA_DB.Where("user_id = ? AND content_id = ?", userID, contentID).Find(&actions).Error
	if err != nil {
		// 出错时返回默认状态
		return response_model.UserInteraction{
			IsLiked:    false,
			IsDisLiked: false,
			IsMark:     false,
		}
	}

	// 初始化互动状态
	interaction := response_model.UserInteraction{
		IsLiked:    false,
		IsDisLiked: false,
		IsMark:     false,
	}

	// 根据查询结果设置互动状态
	for _, action := range actions {
		switch action.ActionType {
		case "like":
			interaction.IsLiked = true
		case "dislike":
			interaction.IsDisLiked = true
		case "mark":
			interaction.IsMark = true
		}
	}

	return interaction
}

// convertToResponse 将 Content 模型转换为 ContentResponse
func convertToResponse(model content.Content, nowUserID uint) response_model.ContentResponse {
	var c ContentService

	// 设置总超时时间（4秒）
	timeout := 4 * time.Second
	doneCh := make(chan struct{})

	// 创建结果变量
	var userInteraction response_model.UserInteraction
	var stats content.ContentStats
	var ratingResult struct {
		AvgScore float64
		Count    int64
	}

	// 启动一个 goroutine 执行所有并发查询
	go func() {
		defer close(doneCh)

		// 创建通道用于接收并发查询结果
		userInteractionChan := make(chan response_model.UserInteraction, 1)
		statsChan := make(chan content.ContentStats, 1)
		ratingChan := make(chan struct {
			AvgScore float64
			Count    int64
		}, 1)

		// 并发执行 getUserInteraction 查询
		go func() {
			// 为每个查询设置单独的超时
			resultChan := make(chan response_model.UserInteraction, 1)
			go func() {
				resultChan <- c.getUserInteraction(model.ID, nowUserID)
			}()

			// 查询超时控制（2秒）
			select {
			case result := <-resultChan:
				userInteractionChan <- result
			case <-time.After(2 * time.Second):
				// 超时返回默认值
				userInteractionChan <- response_model.UserInteraction{
					IsLiked:    false,
					IsDisLiked: false,
					IsMark:     false,
				}
				global.GVA_LOG.Error("获取用户互动状态超时")
			}
		}()

		// 并发执行 ContentStats 查询
		go func() {
			// 为每个查询设置单独的超时
			resultChan := make(chan content.ContentStats, 1)
			go func() {
				var s content.ContentStats
				global.GVA_DB.Where("content_id = ?", model.ID).First(&s)
				resultChan <- s
			}()

			// 查询超时控制（2秒）
			select {
			case result := <-resultChan:
				statsChan <- result
			case <-time.After(2 * time.Second):
				// 超时返回默认值
				statsChan <- content.ContentStats{}
				global.GVA_LOG.Error("获取内容统计数据超时")
			}
		}()

		// 并发执行专业评分查询（如果启用）
		go func() {
			result := struct {
				AvgScore float64
				Count    int64
			}{}

			// 为每个查询设置单独的超时
			resultChan := make(chan struct {
				AvgScore float64
				Count    int64
			}, 1)

			go func() {
				// 只在启用专业评分的情况下才查询评分数据
				if model.EnableProfRating {
					// 创建一个临时结构体来接收聚合查询结果
					var dbResult struct {
						AvgScore float64 `gorm:"column:avg_score"`
						Count    int64   `gorm:"column:count"`
					}
					global.GVA_DB.Model(&content.ContentProfRating{}).
						Where("content_id = ?", model.ID).
						Select("AVG(score) as avg_score, COUNT(*) as count").
						Scan(&dbResult)
					result.AvgScore = dbResult.AvgScore
					result.Count = dbResult.Count
				}
				resultChan <- result
			}()

			// 查询超时控制（2秒）
			select {
			case result := <-resultChan:
				ratingChan <- result
			case <-time.After(2 * time.Second):
				// 超时返回默认值
				ratingChan <- struct {
					AvgScore float64
					Count    int64
				}{}
				global.GVA_LOG.Error("获取专业评分数据超时")
			}
		}()

		// 收集所有结果
		userInteraction = <-userInteractionChan
		stats = <-statsChan
		ratingResult = <-ratingChan
	}()

	// 总超时控制
	select {
	case <-doneCh:
		// 所有查询正常完成
	case <-time.After(timeout):
		// 总超时，使用默认值
		global.GVA_LOG.Error("convertToResponse 总超时")
		// 已经初始化了默认值，继续执行
	}

	return response_model.ContentResponse{
		ID:                model.ID,
		CommunityID:       model.CommunityID,
		PublisherID:       model.PublisherID,
		Type:              model.Type,
		Title:             model.Title,
		Body:              model.Body,
		ParentID:          model.ParentID,
		Status:            model.Status,
		CreateTime:        model.CreateTime,
		UpdateTime:        model.UpdateTime,
		Likes:             stats.LikeCount,     // 从ContentStats获取点赞数
		Dislikes:          stats.DislikeCount,  // 从ContentStats获取点踩数
		Marks:             stats.CollectCount,  // 从ContentStats获取收藏数
		Shares:            stats.ShareCount,    // 从ContentStats获取分享数
		Views:             stats.ViewCount,     // 从ContentStats获取浏览数
		CommentsCount:     stats.CommentsCount, // 从ContentStats获取评论数
		UserInteraction:   userInteraction,
		EnableProfRating:  model.EnableProfRating, // 设置是否启用专业评分
		ProfRatingAverage: ratingResult.AvgScore,  // 设置专业评分平均分
		ProfRatingCount:   ratingResult.Count,     // 设置专业评分数量
	}
}

// GetContentByID 根据 ID 查询内容
func (con *ContentService) GetContentByID(req request_model.GetContentRequest, userID uint) (response_model.ContentResponse, error) {
	var resp response_model.ContentResponse
	var contentModel content.Content

	// 查询数据库
	err := global.GVA_DB.Where("id = ? AND status != ?", req.ID, global.ContentStatusDeleted).First(&contentModel).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return resp, errors.New("内容不存在或已被删除")
		}
		return resp, errors.New("查询内容失败: " + err.Error())
	}
	// 非发布者不可获取审核中与封禁状态详情
	if userID != contentModel.PublisherID && contentModel.Status != global.ContentStatusNormal {
		return resp, errors.New("内容不存在或已被删除")
	}

	// 除了用户自己，否则点击都会增加浏览
	if userID != contentModel.PublisherID {
		go func() {
			viewErr := con.ViewContent(contentModel.ID, userID)
			if viewErr != nil {
				// 打印日志，不阻塞流程
				global.GVA_LOG.Error("增加浏览失败获取失败!", zap.Error(viewErr))
			}
		}()
	}

	// 转换为响应模型 - 已包含UserInteraction，无需重复设置
	resp = convertToResponse(contentModel, userID)

	return resp, nil
}

// ListContent 通用分页查询内容 (优化版)
func (con *ContentService) ListContent(req request_model.ListContentRequest, userID uint) (response_model.PageResult, error) {
	var resp response_model.PageResult
	var contentList []content.Content
	var total int64

	// 构造查询条件
	db := global.GVA_DB.Model(&content.Content{}).Where("status = ?", global.ContentStatusNormal)

	if req.CommunityID != 0 {
		db = db.Where("community_id = ?", req.CommunityID)
	}

	if req.PublisherID != 0 {
		db = db.Where("publisher_id = ?", req.PublisherID)
	}

	if req.Type != 0 {
		db = db.Where("type = ?", req.Type)
		// 当type判断是查询回答，如果是则强校验父id
		if req.Type == global.ContentTypeAnswers {
			if req.ParentID == 0 {
				return resp, errors.New("查询内容总数失败: 查询回答缺少提问id")
			} else {
				db = db.Where("parent_id = ?", req.ParentID)
			}
		}
	}

	// 查询总数
	err := db.Count(&total).Error
	if err != nil {
		return resp, errors.New("查询内容总数失败: " + err.Error())
	}

	// 分页查询
	err = db.Offset((req.Page - 1) * req.PageSize).Limit(req.PageSize).Order("create_time DESC").Find(&contentList).Error
	if err != nil {
		return resp, errors.New("查询内容列表失败: " + err.Error())
	}

	// 转换为响应模型
	var responseList []response_model.ContentResponse
	for _, item := range contentList {
		responseItem := convertToResponse(item, userID)
		responseList = append(responseList, responseItem)
	}

	resp = response_model.PageResult{
		List:     responseList,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}

	return resp, nil
}

// 查看用户的收藏内容
func (con *ContentService) ListMarkContents(req request_model.ListMarksRequest, userID uint) (response_model.PageResult, error) {
	// 查看收藏内容,查询收藏的列表
	var resp response_model.PageResult
	var total int64
	var marks = make([]content.UserAction, 0)
	var contentList = make([]content.Content, 0)
	// 获取用户收藏的内容id
	err := global.GVA_DB.Where("user_id=? AND action_type=?", userID, "mark").Find(&marks).Error
	if err != nil {
		return resp, err
	}
	var ids = make([]int64, len(marks))
	// 获取内容的id字段切片
	for i, item := range marks {
		ids[i] = item.ContentID
	}
	db := global.GVA_DB.Model(&content.Content{}).Where("id IN ?", ids).Where("type = ?", req.Type)
	// 查询收藏的总数
	err = db.Count(&total).Error
	if err != nil {
		return resp, err
	}
	// 查询收藏的内容
	err = db.Offset((req.Page - 1) * req.PageSize).Limit(req.PageSize).Find(&contentList).Error
	if err != nil {
		return resp, err
	}
	// 转化为相应模型
	var responseList []response_model.ContentResponse
	for _, item := range contentList {
		responseItem := convertToResponse(item, userID)
		responseItem.UserInteraction = con.getUserInteraction(item.ID, userID)
		responseList = append(responseList, responseItem)
	}
	resp = response_model.PageResult{
		List:     responseList,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}
	return resp, nil
}

// 查看用户的点赞内容
func (con *ContentService) ListLikeContents(req request_model.ListLikesRequest, userID uint) (response_model.PageResult, error) {
	// 查看点赞内容,查询点赞的列表
	var resp response_model.PageResult
	var total int64
	var likes = make([]content.UserAction, 0)
	var contentList = make([]content.Content, 0)
	// 获取用户点赞的内容id
	db := global.GVA_DB.Where("user_id=? AND action_type=?", userID, "like").Find(&likes)
	var ids = make([]int64, len(likes))
	// 获取内容的id字段切片
	for i, item := range likes {
		ids[i] = item.ContentID
	}
	db = global.GVA_DB.Model(&content.Content{}).Where("id IN ?", ids).Where("type = ?", req.Type)
	// 查询点赞的总数
	err := db.Count(&total).Error
	if err != nil {
		return resp, err
	}
	// 查询点赞的内容
	err = db.Offset((req.Page - 1) * req.PageSize).Limit(req.PageSize).Find(&contentList).Error
	if err != nil {
		return resp, err
	}
	// 转化为相应模型
	var responseList []response_model.ContentResponse
	for _, item := range contentList {
		responseItem := convertToResponse(item, userID)
		responseItem.UserInteraction = con.getUserInteraction(item.ID, userID)
		responseList = append(responseList, responseItem)
	}
	resp = response_model.PageResult{
		List:     responseList,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}
	return resp, nil
}

// LikeContent 点赞内容
// todo: 点赞等操作也要根据专业校验权限
func (con *ContentService) LikeContent(ctx context.Context, contentID int64, userID uint) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var contentModel content.Content
		errContent := tx.Where("id = ?", contentID).First(&contentModel).Error
		if errContent != nil {
			return errContent
		}
		// 检查用户是否已经点赞
		var action content.UserAction
		err := tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "like").First(&action).Error
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		// 如果已经点赞，则取消点赞
		if err == nil {
			// 删除用户操作记录
			err = tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "like").Delete(&content.UserAction{}).Error
			if err != nil {
				return err
			}

			// 减少内容点赞数 - 改为操作ContentStats表
			err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("like_count", gorm.Expr("like_count - 1")).Error
			if err != nil {
				return err
			}
			return nil
		}

		// 如果未点赞，则添加点赞
		// 创建用户操作记录
		userAction := content.UserAction{
			UserID:      userID,
			ContentID:   contentID,
			ActionType:  "like",
			ContentType: int64(contentModel.Type),
		}
		err = tx.Create(&userAction).Error
		if err != nil {
			return err
		}

		// 增加内容点赞数 - 改为操作ContentStats表
		err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("like_count", gorm.Expr("like_count + 1")).Error
		if err != nil {
			return err
		}

		return nil
	})
}

// DislikeContent 点踩内容
func (con *ContentService) DislikeContent(contentID int64, userID uint) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var contentModel content.Content
		errContent := tx.Where("id = ?", contentID).First(&contentModel).Error
		if errContent != nil {
			return errContent
		}
		// 检查用户是否已经点踩
		var action content.UserAction
		err := tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "dislike").First(&action).Error
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		// 如果已经点踩，则取消点踩
		if err == nil {
			// 删除用户操作记录
			err = tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "dislike").Delete(&content.UserAction{}).Error
			if err != nil {
				return err
			}

			// 减少内容点踩数 - 改为操作ContentStats表
			err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("dislike_count", gorm.Expr("dislike_count - 1")).Error
			if err != nil {
				return err
			}
			return nil
		}

		// 如果未点踩，则添加点踩
		// 创建用户操作记录
		userAction := content.UserAction{
			UserID:      userID,
			ContentID:   contentID,
			ActionType:  "dislike",
			ContentType: int64(contentModel.Type),
		}
		err = tx.Create(&userAction).Error
		if err != nil {
			return err
		}

		// 增加内容点踩数 - 改为操作ContentStats表
		err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("dislike_count", gorm.Expr("dislike_count + 1")).Error
		if err != nil {
			return err
		}

		return nil
	})
}

// MarkContent 收藏内容
func (con *ContentService) MarkContent(contentID int64, userID uint) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var contentModel content.Content
		errContent := tx.Where("id = ?", contentID).First(&contentModel).Error
		if errContent != nil {
			return errContent
		}
		// 检查用户是否已经收藏
		var action content.UserAction
		err := tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "mark").First(&action).Error
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		// 如果已经收藏，则取消收藏
		if err == nil {
			// 删除用户操作记录
			err = tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "mark").Delete(&content.UserAction{}).Error
			if err != nil {
				return err
			}

			// 减少内容收藏数 - 改为操作ContentStats表
			err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("collect_count", gorm.Expr("collect_count - 1")).Error
			if err != nil {
				return err
			}
			return nil
		}

		// 如果未收藏，则添加收藏
		// 创建用户操作记录
		userAction := content.UserAction{
			UserID:      userID,
			ContentID:   contentID,
			ActionType:  "mark",
			ContentType: int64(contentModel.Type),
		}
		err = tx.Create(&userAction).Error
		if err != nil {
			return err
		}

		// 增加内容收藏数 - 改为操作ContentStats表
		err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("collect_count", gorm.Expr("collect_count + 1")).Error
		if err != nil {
			return err
		}

		return nil
	})
}

// ShareContent 分享内容
func (con *ContentService) ShareContent(contentID int64, userID uint) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var contentModel content.Content
		errContent := tx.Where("id = ?", contentID).First(&contentModel).Error
		if errContent != nil {
			return errContent
		}
		// 检查用户是否已经分享
		var action content.UserAction
		err := tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "share").First(&action).Error
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		// 如果已经分享，则只增加分享数（允许多次分享）
		// 创建用户操作记录
		if errors.Is(err, gorm.ErrRecordNotFound) {
			userAction := content.UserAction{
				UserID:      userID,
				ContentID:   contentID,
				ActionType:  "share",
				ContentType: int64(contentModel.Type),
			}
			err = tx.Create(&userAction).Error
			if err != nil {
				return err
			}
		}

		// 增加内容分享数 - 改为操作ContentStats表
		err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("share_count", gorm.Expr("share_count + 1")).Error
		if err != nil {
			return err
		}

		return nil
	})
}

// ViewContent 浏览内容（幂等操作）
func (con *ContentService) ViewContent(contentID int64, userID uint) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var contentModel content.Content
		errContent := tx.Where("id = ?", contentID).First(&contentModel).Error
		if errContent != nil {
			return errContent
		}
		// 检查用户是否已经浏览过
		var action content.UserAction
		err := tx.Where("user_id = ? AND content_id = ? AND action_type = ?", userID, contentID, "view").First(&action).Error
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		// 如果已经浏览过，则不再增加浏览数
		if err == nil {
			return nil
		}

		// 如果未浏览过，则记录浏览并增加浏览数
		// 创建用户操作记录
		userAction := content.UserAction{
			UserID:      userID,
			ContentID:   contentID,
			ActionType:  "view",
			ContentType: int64(contentModel.Type),
		}
		err = tx.Create(&userAction).Error
		if err != nil {
			return err
		}

		// 增加内容浏览数 - 改为操作ContentStats表
		err = tx.Model(&content.ContentStats{}).Where("content_id = ?", contentID).Update("view_count", gorm.Expr("view_count + 1")).Error
		if err != nil {
			return err
		}

		return nil
	})
}

// ProfRatingContent 对内容进行专业评分
func (con *ContentService) ProfRatingContent(contentID int64, userID uint, score int) error {
	return global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		// 1. 检查内容是否存在且启用了专业评分
		var contentModel content.Content
		err := tx.Where("id = ? AND status = ? AND enable_prof_rating = ?", contentID, global.ContentStatusNormal, true).First(&contentModel).Error
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return errors.New("内容不存在或未启用专业评分")
			}
			return errors.New("查询内容失败: " + err.Error())
		}
		// 如果是发布者本人，则不可以进行专业度评价
		if contentModel.PublisherID == userID {
			return errors.New("不可以对自己的文章进行专业评价哦~")
		}

		// 2. 检查用户是否已经对该内容进行过评分
		var existingRating content.ContentProfRating
		err = tx.Where("content_id = ? AND user_id = ?", contentID, userID).First(&existingRating).Error
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		// 3. 根据是否已评分执行不同操作
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 用户未评分，添加新评分
			rating := content.ContentProfRating{
				ContentID:   contentID,
				UserID:      userID,
				Score:       score,
				ContentType: int64(contentModel.Type),
			}
			err = tx.Create(&rating).Error
			if err != nil {
				return errors.New("添加评分失败: " + err.Error())
			}
		} else {
			// 用户已评分，更新评分
			err = tx.Model(&content.ContentProfRating{}).
				Where("content_id = ? AND user_id = ?", contentID, userID).
				Update("score", score).Error
			if err != nil {
				return errors.New("更新评分失败: " + err.Error())
			}
		}

		return nil
	})
}

// GetContentProfRating 获取内容的专业评分信息
func (con *ContentService) GetContentProfRating(contentID int64, userID uint) (response_model.ProfRatingResponse, error) {
	var resp response_model.ProfRatingResponse

	// 1. 查询内容基本信息
	var contentModel content.Content
	err := global.GVA_DB.Where("id = ? AND status = ?", contentID, global.ContentStatusNormal).First(&contentModel).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return resp, errors.New("内容不存在")
		}
		return resp, errors.New("查询内容失败: " + err.Error())
	}

	// 2. 获取评分统计信息
	var avgScore float64
	var count int64
	// 计算平均分和评分数量 - 修复Scan调用
	// 创建一个临时结构体来接收聚合查询结果
	var result struct {
		AvgScore float64 `gorm:"column:avg_score"`
		Count    int64   `gorm:"column:count"`
	}
	global.GVA_DB.Model(&content.ContentProfRating{}).
		Where("content_id = ?", contentID).
		Select("AVG(score) as avg_score, COUNT(*) as count").
		Scan(&result)
	avgScore = result.AvgScore
	count = result.Count

	// 3. 获取当前用户的评分（如果有）
	var userRating float64
	var hasRated bool
	if userID > 0 {
		var rating content.ContentProfRating
		err = global.GVA_DB.Where("content_id = ? AND user_id = ?", contentID, userID).First(&rating).Error
		if err == nil {
			userRating = float64(rating.Score)
			hasRated = true
		}
	}

	// 4. 构造响应
	resp = response_model.ProfRatingResponse{
		ContentID:        contentID,
		EnableProfRating: contentModel.EnableProfRating,
		AverageScore:     avgScore,
		RatingCount:      count,
		UserRating:       userRating,
		HasRated:         hasRated,
	}

	return resp, nil
}

// ValidateContentInteraction 统一的内容互动校验，只有本专业类认证的用户可以操作
func (con *ContentService) ValidateContentInteraction(contentID int64, userID uint) error {
	//// 1. 查询用户所在社区，获取社区id
	//communityID, err := CommunityServiceApp.GetUserCommunityID(userID)
	//if err != nil {
	//	return err
	//}

	// 1. 获取用户所属专业
	var user, err = system.UserServiceApp.GetUserByID(userID)
	if err != nil {
		return err
	}
	if user.Major <= 0 {
		return fmt.Errorf("invalid user major. user_id=%d, major_id=%d", user.ID, user.Major)
	}
	// 2. 获取内容信息
	var contentModel content.Content
	err = global.GVA_DB.Where("id = ? AND status = ?", contentID, global.ContentStatusNormal).First(&contentModel).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("内容不存在或已被删除")
		}
		return errors.New("查询内容失败: " + err.Error())
	}

	// 3. 判断内容type，如果为 ContentTypeAnswers 回答所有人可互动 直接返回nil
	if contentModel.Type == global.ContentTypeAnswers {
		return nil
	}

	// 4. 专业粒度权限校验
	var errCheck = CommunityServiceApp.CheckUserMajorWithCommunity(user.Major, contentModel.CommunityID)
	if errCheck != nil {
		return fmt.Errorf("权限校验不通过! err=%w", errCheck)
	}

	return nil
}

// GetUserRelatedContent 获取用户相关内容（互动过的内容和自身发布的内容）
func (con *ContentService) GetUserRelatedContent(req request_model.UserRelatedContentRequest, userID uint) (response_model.PageResult, error) {
	var resp response_model.PageResult
	var contentIDs []int64
	var total int64
	var err error

	// 确定要查询的内容类型
	queryBuilder := global.GVA_DB.Model(&content.Content{Status: global.ContentStatusNormal})

	switch req.IncludeType {
	case "interacted":
		// 查询用户互动过的内容
		// 从UserAction表获取用户互动过的内容ID
		actionTypes := req.ActionTypes
		if len(actionTypes) == 0 {
			actionTypes = []string{"like", "dislike", "mark", "share"}
		}

		err = global.GVA_DB.Model(&content.UserAction{}).
			Where("user_id = ? AND action_type IN ?", userID, actionTypes).
			Pluck("content_id", &contentIDs).Error
		if err != nil {
			return resp, errors.New("查询用户互动内容失败: " + err.Error())
		}

		// 添加专业度评价的内容
		var profRatingContentIDs []int64
		err = global.GVA_DB.Model(&content.ContentProfRating{}).
			Where("user_id = ?", userID).
			Pluck("content_id", &profRatingContentIDs).Error
		if err != nil {
			return resp, errors.New("查询用户专业度评价内容失败: " + err.Error())
		}

		// 合并内容ID
		contentIDs = append(contentIDs, profRatingContentIDs...)

		// 如果没有内容ID，直接返回空结果
		if len(contentIDs) == 0 {
			resp.List = []response_model.ContentResponse{}
			resp.Total = 0
			resp.Page = req.Page
			resp.PageSize = req.PageSize
			return resp, nil
		}

		// 去重
		contentIDs = removeDuplicates(contentIDs)

		// 查询内容列表
		queryBuilder = queryBuilder.Where("id IN ?", contentIDs)

	case "published":
		// 查询用户发布的内容
		queryBuilder = queryBuilder.Where("publisher_id = ?", userID)

	default:
		// 查询全部（互动过的内容和自身发布的内容）
		// 先获取用户互动过的内容ID
		var interactedContentIDs []int64

		// 从UserAction表获取用户互动过的内容ID
		actionTypes := req.ActionTypes
		if len(actionTypes) == 0 {
			actionTypes = []string{"like", "dislike", "mark", "share"}
		}

		err = global.GVA_DB.Model(&content.UserAction{}).
			Where("user_id = ? AND action_type IN ?", userID, actionTypes).
			Pluck("content_id", &interactedContentIDs).Error
		if err != nil {
			return resp, errors.New("查询用户互动内容失败: " + err.Error())
		}

		// 添加专业度评价的内容
		var profRatingContentIDs []int64
		err = global.GVA_DB.Model(&content.ContentProfRating{}).
			Where("user_id = ?", userID).
			Pluck("content_id", &profRatingContentIDs).Error
		if err != nil {
			return resp, errors.New("查询用户专业度评价内容失败: " + err.Error())
		}

		// 合并内容ID
		interactedContentIDs = append(interactedContentIDs, profRatingContentIDs...)

		// 构建OR查询条件
		if len(interactedContentIDs) > 0 {
			queryBuilder = queryBuilder.Where("publisher_id = ? OR id IN ?", userID, interactedContentIDs)
		} else {
			queryBuilder = queryBuilder.Where("publisher_id = ?", userID)
		}
	}

	// 筛选内容类型
	if req.ContentType > 0 {
		queryBuilder = queryBuilder.Where("type = ?", req.ContentType)
	}

	// 统计总数
	err = queryBuilder.Count(&total).Error
	if err != nil {
		return resp, errors.New("统计内容总数失败: " + err.Error())
	}

	// 分页查询
	var contentList []content.Content
	offset := (req.Page - 1) * req.PageSize
	err = queryBuilder.Order("create_time DESC").Limit(req.PageSize).Offset(offset).Find(&contentList).Error
	if err != nil {
		return resp, errors.New("查询内容列表失败: " + err.Error())
	}

	// 转换为响应模型
	var responseList []response_model.ContentResponse
	for _, item := range contentList {
		responseItem := convertToResponse(item, userID)
		responseList = append(responseList, responseItem)
	}

	resp = response_model.PageResult{
		List:     responseList,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}

	return resp, nil
}

// removeDuplicates 移除切片中的重复元素
func removeDuplicates[T comparable](sliceList []T) []T {
	allKeys := make(map[T]bool)
	list := []T{}
	for _, item := range sliceList {
		if _, value := allKeys[item]; !value {
			allKeys[item] = true
			list = append(list, item)
		}
	}
	return list
}

// GetDisciplineCommunityContents 获取学科类社区的内容列表 (优化版)
func (con *ContentService) GetDisciplineCommunityContents(req community_request.GetDisciplineCommunityContentRequest, userID uint) (response_model.PageResult, error) {
	var resp response_model.PageResult
	var total int64
	var contents []content.Content

	// 创建社区Redis工具实例
	communityRedis := utils.NewCommunityRedis()

	// 获取内容ID列表
	contentIDs, err := communityRedis.GetDisciplineCommunityContents(req.CommunityID, req.Type)
	if err != nil {
		return resp, err
	}

	// 如果没有内容，直接返回
	if len(contentIDs) == 0 {
		resp.List = []response_model.ContentResponse{}
		resp.Total = 0
		return resp, nil
	}

	// 查询内容总数
	total = int64(len(contentIDs))

	// 分页处理
	start := (req.PageInfo.Page - 1) * req.PageInfo.PageSize
	end := start + req.PageInfo.PageSize
	if end > len(contentIDs) {
		end = len(contentIDs)
	}
	pagedIDs := contentIDs[start:end]

	for _, contentID := range pagedIDs {
		var contentInfo content.Content
		// 查询内容详情
		query := global.GVA_DB.Where("id = ? AND status = ?", contentID, global.ContentStatusNormal)

		// 如果指定了类型，添加类型过滤
		if req.Type != 0 {
			query = query.Where("type = ?", req.Type)
		}

		if errFirst := query.First(&contentInfo).Error; errFirst == nil {
			contents = append(contents, contentInfo)
		}
	}

	// 转换为响应模型
	var responseList []response_model.ContentResponse
	for _, item := range contents {
		responseItem := convertToResponse(item, userID)
		responseList = append(responseList, responseItem)
	}

	// 构建响应
	resp.List = responseList
	resp.Total = total
	resp.Page = req.PageInfo.Page
	resp.PageSize = req.PageInfo.PageSize

	return resp, nil
}

// GetUserContentActions 查询用户内容操作记录
func (con *ContentService) GetUserContentActions(ctx *gin.Context, req request_model.ContentUserActionRequest, currentUserID uint) (response_model.ContentUserActionResponse, error) {
	uri := "GetUserContentActions"
	logID := utils.GetLogID(ctx)
	var resp response_model.ContentUserActionResponse
	var contentIDs []int64
	var total int64
	var actionTimeMap map[int64]int64 = make(map[int64]int64)
	var err error

	// 确定要查询的用户ID
	queryUserID := currentUserID
	if req.UserID > 0 {
		queryUserID = req.UserID
	}

	var actionType = global.ActionType(req.ActionType)
	// 根据ActionType从不同的表查询
	switch actionType {
	case global.Publish:
		// ActionType=-1: 从content表查询用户的发布记录
		queryBuilder := global.GVA_DB.Model(&content.Content{Status: global.ContentStatusNormal}).
			Where("publisher_id = ?", queryUserID)

		// 筛选内容类型
		if req.ContentType > 0 {
			queryBuilder = queryBuilder.Where("type = ? and status = ?", req.ContentType, global.ContentStatusNormal)
		}

		// 统计总数
		err = queryBuilder.Count(&total).Error
		if err != nil {
			global.GVA_LOG.Warn("统计内容总数失败！", zap.Error(err), zap.String("uri", uri), zap.Int64("userID", int64(queryUserID)), zap.String("logID", logID), zap.Int("contentType", int(req.ContentType)), zap.Int("actionType", int(req.ActionType)))
			return resp, errors.New("统计内容总数失败: " + err.Error())
		}

		// 分页查询
		var contentList []content.Content
		offset := (req.Page - 1) * req.PageSize
		err = queryBuilder.Order("create_time DESC").Limit(req.PageSize).Offset(offset).Find(&contentList).Error
		if err != nil {
			global.GVA_LOG.Warn("查询用户发布内容列表失败！", zap.Error(err), zap.Int64("userID", int64(queryUserID)), zap.String("logID", logID), zap.Int("contentType", int(req.ContentType)), zap.Int("actionType", int(req.ActionType)))
			return resp, errors.New("查询内容列表失败: " + err.Error())
		}

		// 转换为ContentUserActionVO
		var contentVOs []response_model.ContentUserActionVO
		for _, item := range contentList {
			// 获取发布者信息
			var publisher sysModel.SysUser
			global.GVA_DB.Where("id = ?", item.PublisherID).
				Select("nick_name", "header_img").
				First(&publisher)

			var parentContentModel, parentPublisherModel = content.Content{}, sysModel.SysUser{}

			var errParent error

			if item.ParentID > 0 {
				parentContentModel, parentPublisherModel, errParent = con.GetContentPublishInfo(item.ParentID)
				if errParent != nil {
					continue
				}
			}

			// 查询统计数据
			var contentStats content.ContentStats
			if statsErr := global.GVA_DB.Where("content_id = ?", item.ID).First(&contentStats).Error; statsErr != nil {
				continue
			}

			contentVO := response_model.ContentUserActionVO{
				ID:             uint64(item.ID),
				Type:           item.Type,
				Title:          item.Title,
				Body:           item.Body,
				CreateTime:     item.CreateTime.Unix(),
				ParentID:       item.ParentID,
				PublisherID:    uint64(item.PublisherID),
				PublisherName:  publisher.NickName,
				PublisherImage: publisher.HeaderImg,
				ActionTime:     item.CreateTime.Unix(), // 发布时间即为操作时间
				LikeCount:      contentStats.LikeCount,
				CollectCount:   contentStats.CollectCount,
				CommentsCount:  contentStats.CommentsCount,

				ParentPublisherID:    uint64(parentContentModel.PublisherID),
				ParentPublisherName:  parentPublisherModel.NickName,
				ParentPublisherImage: parentPublisherModel.HeaderImg,
				ParentPublishTime:    parentContentModel.CreateTime.Unix(),
				ParentType:           parentContentModel.Type,
				ParentContentTitle:   parentContentModel.Title,
				ParentContentBody:    parentContentModel.Body,
			}
			contentVOs = append(contentVOs, contentVO)
		}

		resp = response_model.ContentUserActionResponse{
			Total:    total,
			Contents: contentVOs,
		}

	case global.Rating:
		// ActionType=-2: 从content_profe_rating表查询用户的评价记录
		queryBuilder := global.GVA_DB.Model(&content.ContentProfRating{}).
			Where("user_id = ?", queryUserID)
		if req.ContentType > 0 {
			queryBuilder = queryBuilder.Where("content_type = ?", req.ContentType)
		}

		// 统计总数
		err = queryBuilder.Count(&total).Error
		if err != nil {
			return resp, errors.New("统计评价总数失败: " + err.Error())
		}

		// 分页查询评价记录
		var ratingList []content.ContentProfRating
		offset := (req.Page - 1) * req.PageSize
		err = queryBuilder.Order("created_at DESC").Limit(req.PageSize).Offset(offset).Find(&ratingList).Error
		if err != nil {
			return resp, errors.New("查询评价记录失败: " + err.Error())
		}

		// 提取内容ID
		for _, rating := range ratingList {
			contentIDs = append(contentIDs, rating.ContentID)
			actionTimeMap[rating.ContentID] = rating.CreatedAt.Unix()
		}

	case global.Like, global.Mark:
		// ActionType=1或3: 从user_action表查询用户对应的操作记录
		// 转换ActionType到字符串
		var actionTypeStr string
		if actionType == global.Like {
			actionTypeStr = "like"
		} else if actionType == global.Mark {
			actionTypeStr = "mark"
		}

		queryBuilder := global.GVA_DB.Model(&content.UserAction{}).
			Where("user_id = ? AND action_type = ?", queryUserID, actionTypeStr)
		if req.ContentType > 0 {
			queryBuilder = queryBuilder.Where("content_type = ?", req.ContentType)
		}

		// 统计总数
		err = queryBuilder.Count(&total).Error
		if err != nil {
			return resp, errors.New("统计操作总数失败: " + err.Error())
		}

		// 分页查询操作记录
		var actionList []content.UserAction
		offset := (req.Page - 1) * req.PageSize
		err = queryBuilder.Order("create_time DESC").Limit(req.PageSize).Offset(offset).Find(&actionList).Error
		if err != nil {
			return resp, errors.New("查询操作记录失败: " + err.Error())
		}

		// 提取内容ID
		for _, action := range actionList {
			contentIDs = append(contentIDs, action.ContentID)
			actionTimeMap[action.ContentID] = action.CreateTime.Unix()
		}

	default:
		return resp, errors.New("不支持的操作类型")
	}

	// 对于ActionType=-2、1、3的情况，需要查询内容详情
	if (actionType == global.Rating || actionType == global.Like || actionType == global.Mark) && len(contentIDs) > 0 {
		var contentVOs []response_model.ContentUserActionVO

		for _, contentID := range contentIDs {
			// 获取内容信息
			var contentModel, publisherModel, err = con.GetContentPublishInfo(contentID)
			if err != nil {
				continue
			}
			var parentContentModel, parentPublisherModel = content.Content{}, sysModel.SysUser{}
			var errParent error

			if contentModel.ParentID > 0 {
				parentContentModel, parentPublisherModel, errParent = con.GetContentPublishInfo(contentModel.ParentID)
				if errParent != nil {
					continue
				}
			}
			// 查询统计数据
			var contentStats content.ContentStats
			if statsErr := global.GVA_DB.Where("content_id = ?", contentID).First(&contentStats).Error; statsErr != nil {
				continue
			}

			contentVO := response_model.ContentUserActionVO{
				ID:             uint64(contentModel.ID),
				Type:           contentModel.Type,
				Title:          contentModel.Title,
				Body:           contentModel.Body,
				CreateTime:     contentModel.CreateTime.Unix(),
				ParentID:       contentModel.ParentID,
				PublisherID:    uint64(contentModel.PublisherID),
				PublisherName:  publisherModel.NickName,
				PublisherImage: publisherModel.HeaderImg,
				ActionTime:     actionTimeMap[contentID], // 使用操作时间
				LikeCount:      contentStats.LikeCount,
				CollectCount:   contentStats.CollectCount,
				CommentsCount:  contentStats.CommentsCount,

				ParentPublisherID:    uint64(parentContentModel.PublisherID),
				ParentPublisherName:  parentPublisherModel.NickName,
				ParentPublisherImage: parentPublisherModel.HeaderImg,
				ParentPublishTime:    parentContentModel.CreateTime.Unix(),
				ParentType:           parentContentModel.Type,
				ParentContentTitle:   parentContentModel.Title,
				ParentContentBody:    parentContentModel.Body,
			}
			contentVOs = append(contentVOs, contentVO)
		}
		resp = response_model.ContentUserActionResponse{
			Total:    total,
			Contents: contentVOs,
		}
	}

	return resp, nil
}

// GetContentPublishInfo 根据content_id获取内容发布信息，包含内容本身信息、内容发布者信息
func (c *ContentService) GetContentPublishInfo(contentID int64) (content.Content, sysModel.SysUser, error) {
	var contentModel content.Content
	err := global.GVA_DB.Where("id = ?", contentID).First(&contentModel).Error
	if err != nil {
		return content.Content{}, sysModel.SysUser{}, err
	}

	var publisher sysModel.SysUser
	err = global.GVA_DB.Where("id = ?", contentModel.PublisherID).
		Select("nick_name", "header_img").
		First(&publisher).Error
	if err != nil {
		return content.Content{}, sysModel.SysUser{}, err
	}

	return contentModel, publisher, nil
}
